home *** CD-ROM | disk | FTP | other *** search
/ Just Call Me Internet / Just Call Me Internet.iso / prog / atari / m2 / cat3src / cat / itkcmds.m < prev    next >
Text File  |  1997-10-26  |  64KB  |  2,000 lines
  1. MODULE ITKCmds;
  2.  
  3. FROM SYSTEM     IMPORT ADDRESS, ADR, TSIZE, CADR, ASSEMBLER, CALLSYS;
  4.  
  5. (* MM2-Module *)
  6. FROM Storage    IMPORT ALLOCATE, DEALLOCATE;
  7. IMPORT Block, BinOps, Lists, Strings, StrConv, GrafBase;
  8. FROM Characters         IMPORT CR, LF, SUB;
  9.  
  10. (* Magic-Module *)
  11. IMPORT MagicStrings, MagicAES, mtTextfiles, mtAppl, mtUtils, mtDials, 
  12.        MagicDOS, mtAlerts;
  13. FROM MagicAES           IMPORT  GBOX, GIMAGE, GIBOX, GBUTTON, GSTRING,
  14.                                 SELECTABLE, DEFAULT, Exit, LASTOB, OUTLINED,
  15.                                 DRAW3D, SHADOWED, OBJECT, GrafMkstate, 
  16.                                 PtrBITBLK, GICON, FL3DBAK;
  17. FROM MagicSys   IMPORT  Nil, Null, Bit0, Bit1, Bit2, Bit3, Bit4, Bit5, Bit6,
  18.                         Bit7, Bit8, Bit9, Bit10, Bit11, Bit12, Bit13, Bit14,
  19.                         Bit15;
  20. (* CAT-Module *)
  21. FROM Void       IMPORT v;
  22.  
  23. IMPORT CatGlobal, CatTypes, Infofiles, MTE, MausTauschrsc, ListHelp, 
  24.        ListDl, WinDials, ConvertDate, MTPaths, data, GroupSelect,
  25.        CatUtil, ConfVars, Varnames, UserInformation, CatHelp;
  26.  
  27. CONST   
  28.     maxInternalCmds = 8;
  29.  
  30.  
  31. TYPE    
  32.  
  33.     tIntCmdType = RECORD
  34.                     intIdent    : INTEGER;
  35.                     intVersion  : INTEGER;
  36.                   END;
  37.     
  38.     tInternalCmds = ARRAY [0..maxInternalCmds-1] OF tIntCmdType;
  39.     
  40.     MidTextPtr  = POINTER TO ARRAY [0..MAX(INTEGER)] OF CHAR;
  41.  
  42.     tCmdType    = (tcSingle,        (* TE *)
  43.                    tcMultiple,      (* TB *)
  44.                    tcConfig);       (* TK *)
  45.  
  46.     tParamType  = (tpConst,         (* C *)
  47.                    tpEnum,          (* FA *)    (* Buttons *)
  48.                    tpEnumSet,       (* FM *)    (* Buttons *)
  49.                    tpMTDate,        (* FD *)    (* Editfeld *)
  50.                    tpDate,          (* Fd *)    (* Editfeld *)
  51.                    tpString,        (* FS *)    (* Editfeld *)
  52.                    tpPassword,      (* FP *)    (* Editfeld *)
  53.                    tpNewPassword,   (* Fp *)    (* Editfeld *)
  54.                    tpUsername,      (* FU *)    (* Editfeld, Button *)
  55.                    tpInt,           (* FI *)    (* Editfeld num *)
  56.                    tpRange,         (* FIm,n *) (* Editfeld num *)
  57.                    tpGroup,         (* FG *)    (* Editfeld, Button *)
  58.                    tpChiefGroup);   (* Fg *)    (* Editfeld, Button *)
  59.                    
  60.     
  61.     OneCommand  = 
  62.       RECORD
  63.         cmdName : CatTypes.String255;   (* Name des Kommnandos *)
  64.         cmdHelp : MidTextPtr;           (* Hilfetext zum Kommando, 
  65.                                          * einzelne Zeilen mit CR/LF 
  66.                                          * getrennt *)
  67.         cmdVersion : INTEGER;           (* Versionsnummer des Kommandos *)
  68.         cmdIdent: INTEGER;              (* Identifikationsnummer des Kommandos *)
  69.         cmdType : tCmdType;             (* Kommandotyp *)
  70.         cmdParms: Lists.List;           (* Liste der Parameter *)
  71.         hasParms: BOOLEAN;
  72.         selected: BOOLEAN;            (* Fr Darstellung in Listbox *)
  73.       END;
  74.       
  75.     OneParam   = 
  76.       RECORD
  77.         paramName: CatTypes.String255;
  78.         paramHelp: MidTextPtr;
  79.         paramType: tParamType;
  80.         paramEnum: Lists.List;
  81.         paramDflt: CatTypes.String255;  (* Default-Wert fr Parameter *)
  82.         paramMin : LONGINT;             (* Min-Wert fr Integer-Bereich, ggf. Maxl„nge des Strings *)
  83.         paramMax : LONGINT;             (* Max-Wert fr Integer-Bereich *)
  84.         optional : BOOLEAN;             (* Parameter ist optional *)
  85.         hasEnums : BOOLEAN;             (* Hat Enum-Werte *)
  86.         obLow    : INTEGER;
  87.         obHigh   : INTEGER;
  88.       END;
  89.  
  90.     OneEnum    = 
  91.       RECORD
  92.         enumName:  CatTypes.String255;  (* Kurzbeschreibung des Enum-Parameters *)
  93.         enumValue: CatTypes.String255;  (* Werte dieses Enum-Parameters *)
  94.         obLow    : INTEGER;
  95.         obHigh   : INTEGER;
  96.       END;
  97.  
  98.     (* Zeiger auf die Datentypen *)    
  99.  
  100.     pOneCommand = POINTER TO OneCommand;
  101.     pOneParam   = POINTER TO OneParam;
  102.     pOneEnum    = POINTER TO OneEnum;
  103.  
  104. CONST
  105.     internalCmds = tInternalCmds{
  106.                    {1,0},           (* PMs anfordern *)
  107.                    {2,0},           (* eigene PMs zurcksenden *)
  108.                    {3,0},           (* PM-Status anfordern *)
  109.                    {4,0},           (* ”ffentliche Mitteilungen anfordern *)
  110.                    {5,0},           (* eigene ”ffentliche Mitteilungen zurcksenden *)
  111.                    {6,0},           (* Gruppenumbenennungsinformationen anfordern *)
  112.                    {8,0},           (* Maximalgr”že des Outfiles einstellen *)
  113.                    {36,0}           (* Gruppen bestellen/abstellen *)
  114.                    };
  115.  
  116. CONST   noITKAlert = "[1][CAT:|Das Infofile ITK steht nicht|zur Verfgung!][[OK]";
  117.  
  118.         OkBut       = "[OK";
  119.         CancelBut   = "[Abbruch";
  120.         PreviewBut  = "[Preview";
  121.         HelpBut     = "Help";
  122.  
  123.         eEnumCheck1     = "[3][CAT:|Aus der Aufz„hlung|'";
  124.         eEnumCheck2     = "'|muž mindestens ein Wert|selektiert werden!][[OK]";
  125.         eEmptyParm1     = "[3][CAT:|Der Parameter|'";
  126.         eEmptyParm2     = "'|darf nicht leer sein!][[OK]";
  127.         eDateAlt1       = "[3][CAT:|Der Wert im Feld|'";
  128.         eDateAlt2       = "'|ist kein gltiges Datum!][[OK]";
  129.         eRangeAlt1      = "[3][CAT:|Der Wert im Feld|'";
  130.         eRangeAlt2      = "'|muž zwischen ";
  131.         eRangeAlt3      = " und ";
  132.         eRangeAlt4      = "|liegen!][[OK]";
  133.         eSaveCmd1       = "[2][CAT:|Soll die Einstellung fr das Kommando|'";
  134.         eSaveCmd2       = "'|dauerhaft gespeichert werden oder|soll es nur einmal gesendet werden?][[Speichern|[Einmal|:[Abbruch]";
  135.         eSaveConfig     = "[2][CAT:|Die Konfiguration wurde ge„ndert.|Damit diese Einstellung erhalten|bleibt, mssen die Optionen gesichert werden.|Optionen jetzt sichern?][[Speichern|:[Abbruch]";
  136.         eDataType       = "[3][CAT:|In der ITK ist ein unbekannter|Datentyp bei Kommando & enthalten.][:[Abbruch]";
  137.         eUnknown        = "[3][CAT:|Beim Parsen der ITK ist|ein unerwarteter Fehler aufgetreten.|Bitte schicken sie das ITK|an Dirk Steins @ K2][:[Abbruch]";
  138.         ePreview1       = "[1][CAT:|Das Kommando fr die MAUS sieht mit|den aktuellen Daten wie folgt aus:|'";
  139.         ePreview2       = "'][[OK]";
  140.  
  141.         errMemErr       = 2000;
  142.         errDataType     = 2001;
  143.  
  144.  
  145. VAR     cmds            : Lists.List;        
  146.         globalLength    : INTEGER;
  147.  
  148. CONST   cMaxChars =     255;    (* Maximale Zeichenzahl pro Zeile *)
  149.         cMaxText =        9;    (* Maximale Anzahl Zeilen *)
  150.         cMaxButt =        4;    (* Maximale Anzahl Buttons *)
  151.         cMaxIcon =      256;    (* Maximale Anzahl Iconslots *)
  152.         cMaxTeds =        9;    (* Maximale Anzahl Editfelder *)
  153.         
  154. CONST   Box =           0;
  155.         Mover =         1;
  156.         Header =        2;      (* šberschrift *)
  157.  
  158. CONST   Left =          0;
  159.         Center =        1;
  160.         Right =         2;
  161.  
  162. TYPE    tString =       ARRAY [0..cMaxChars-1] OF CHAR;
  163.         ShortKeys =     ['A'..'Z'];
  164.         KeySet =        SET OF ShortKeys;
  165.  
  166. VAR     Tree:           ARRAY [0..255] OF MagicAES.OBJECT;
  167.         Teds:           ARRAY [0..cMaxTeds] OF MagicAES.TEDINFO;
  168.         Text:           ARRAY [0..cMaxText] OF tString;
  169.         Button:         ARRAY [0..cMaxButt] OF RECORD
  170.                                                 text: tString;
  171.                                                 objc: INTEGER;
  172.                                                END;
  173.         currObIdx:      INTEGER;
  174.         tedIdx:         INTEGER;
  175.         theTree:        mtUtils.tObjcTree;
  176.         lastyPos:       INTEGER;
  177.         globErr:        INTEGER;
  178.         lastCmd:        INTEGER;
  179.         
  180.         helpButIdx:     INTEGER;
  181.         okButIdx:       INTEGER;
  182.         cancelButIdx:   INTEGER;
  183.         previewButIdx:  INTEGER;
  184.         usedKeys:       KeySet;
  185.  
  186.         CmdBox:         ADDRESS;
  187.  
  188. (*----------------------------------------------------------------------
  189.  * Zusatzfunktionen fr die Listen
  190.  *----------------------------------------------------------------------*)
  191.  
  192. TYPE    delEntryProc = PROCEDURE (VAR ADDRESS);
  193.  
  194.  
  195. PROCEDURE DeleteSimpleList (VAR l: Lists.List; killCarrier: BOOLEAN;
  196.                             deleteEntry : delEntryProc);
  197.  
  198. VAR   entry: ADDRESS;
  199.  
  200. BEGIN
  201.   Lists.ResetList (l);
  202.   entry := Lists.PrevEntry (l);
  203.   WHILE entry # NIL DO
  204.     Lists.RemoveEntry (l, v.bool);
  205.     deleteEntry (entry);
  206.     entry := Lists.CurrentEntry (l);
  207.   END;
  208.   IF killCarrier THEN Lists.DeleteList (l, v.bool) END;
  209. END DeleteSimpleList;
  210.  
  211. PROCEDURE delEnum (VAR entry : ADDRESS);
  212. BEGIN
  213.   DEALLOCATE (entry, 0);
  214. END delEnum;
  215.  
  216. PROCEDURE delParam (VAR entry : ADDRESS);
  217.   VAR pParam  : pOneParam;
  218. BEGIN
  219.   pParam := entry;
  220.   IF pParam^.hasEnums
  221.   THEN
  222.     DeleteSimpleList (pParam^.paramEnum, TRUE, delEnum);
  223.   END;
  224.   IF pParam^.paramHelp # NIL
  225.   THEN
  226.     DEALLOCATE (pParam^.paramHelp, 0);
  227.   END;
  228.   DEALLOCATE (entry, 0);
  229. END delParam;
  230.  
  231. PROCEDURE delCmd (VAR entry : ADDRESS);
  232.   VAR pCmd  : pOneCommand;
  233. BEGIN
  234.   pCmd := entry;
  235.   IF pCmd^.hasParms
  236.   THEN
  237.     DeleteSimpleList (pCmd^.cmdParms, TRUE, delParam);
  238.   END;
  239.   IF pCmd^.cmdHelp # NIL
  240.   THEN
  241.     DEALLOCATE (pCmd^.cmdHelp, 0);
  242.   END;
  243.   DEALLOCATE (entry, 0);
  244. END delCmd;
  245.  
  246. (*----------------------------------------------------------------------
  247.  * Interne Stringfunktionen
  248.  *----------------------------------------------------------------------*)
  249.  
  250. PROCEDURE StripShortcut (REF paramName: ARRAY OF CHAR;
  251.                          VAR pName : ARRAY OF CHAR);
  252.   VAR p : INTEGER;
  253. BEGIN
  254.   MagicStrings.Assign (paramName, pName);
  255.   p := Strings.Pos ("[", pName, 0);
  256.   IF p >= 0
  257.   THEN
  258.     MagicStrings.Delete (pName, p, 1);
  259.   END;
  260. END StripShortcut;
  261.  
  262.  
  263. (*----------------------------------------------------------------------
  264.  * Hilfe zu einem Kommando zusammenbauen
  265.  *----------------------------------------------------------------------*)
  266. TYPE tHelpLine  = ARRAY [0..70] OF CHAR;
  267.      pHelpLine  = POINTER TO tHelpLine;
  268.  
  269. CONST   helpLineLength = 65;
  270.      
  271. PROCEDURE AddToHelp (REF str: ARRAY OF CHAR; VAR helpList: Lists.List): BOOLEAN;
  272.   VAR helpLine : pHelpLine;
  273.       fromPos,
  274.       toPos    : INTEGER;
  275. BEGIN
  276.   IF str[0] # 0C
  277.   THEN
  278.     NEW (helpLine);
  279.     IF helpLine = NIL
  280.     THEN
  281.       MTE.noMemAlert();
  282.       DeleteSimpleList (helpList, TRUE, delEnum);
  283.       RETURN FALSE;
  284.     END;
  285.     fromPos := 0;
  286.     toPos := LENGTH (str);
  287.     WHILE (fromPos < toPos) DO
  288.       NEW (helpLine);
  289.       IF helpLine = NIL
  290.       THEN
  291.         MTE.noMemAlert();
  292.         DeleteSimpleList (helpList, TRUE, delEnum);
  293.         RETURN FALSE;
  294.       END;
  295.       IF toPos - fromPos > helpLineLength - 1 
  296.       THEN
  297.         (* Umbruch an Wortgrenze durchfhren *)
  298.         toPos := fromPos  + helpLineLength-1;
  299.         WHILE (str[toPos] # ' ') & (toPos > fromPos) DO DEC (toPos); END;
  300.         IF toPos = fromPos THEN toPos := fromPos + helpLineLength - 1 END;
  301.       END;
  302.       MagicStrings.Copy (str, fromPos, toPos - fromPos, helpLine^);
  303.       Lists.AppendEntry (helpList, helpLine, v.bool);
  304.       IF v.bool
  305.       THEN
  306.         MTE.noMemAlert();
  307.         DeleteSimpleList (helpList, TRUE, delEnum);
  308.         RETURN FALSE
  309.       END;
  310.       fromPos := toPos + 1;
  311.       toPos := LENGTH (str);
  312.     END;
  313.   END;
  314.   RETURN TRUE;
  315. END AddToHelp;
  316.  
  317. PROCEDURE AddParmHelp (pParm: pOneParam; VAR helpList: Lists.List): BOOLEAN;
  318.   VAR pName : CatTypes.String255;
  319. BEGIN
  320.   WITH pParm^ DO
  321.     IF paramHelp # NIL
  322.     THEN
  323.       StripShortcut (paramName, pName);
  324.       MagicStrings.Insert ("Parameter: ", pName, 0);
  325.       IF ~AddToHelp (pName, helpList)
  326.       THEN
  327.         RETURN FALSE
  328.       END;
  329.       IF ~AddToHelp (" ", helpList)
  330.       THEN
  331.         RETURN FALSE
  332.       END;
  333.       IF ~AddToHelp (paramHelp^, helpList)
  334.       THEN
  335.         RETURN FALSE
  336.       END;
  337.       IF ~AddToHelp (" ", helpList)
  338.       THEN
  339.         RETURN FALSE
  340.       END;
  341.     END;
  342.   END;
  343.   RETURN TRUE;
  344. END AddParmHelp;
  345.  
  346. PROCEDURE BuildHelp (pCmd: pOneCommand; VAR helpList: Lists.List): BOOLEAN;
  347.   VAR pParm : pOneParam;
  348. BEGIN
  349.   WITH pCmd^ DO
  350.     Lists.CreateList (helpList, v.bool);
  351.     IF v.bool
  352.     THEN
  353.       MTE.noMemAlert();
  354.       RETURN FALSE;
  355.     END;
  356.     IF cmdHelp # NIL
  357.     THEN
  358.       IF ~AddToHelp (cmdName, helpList)
  359.       THEN
  360.         RETURN FALSE
  361.       END;
  362.       IF ~AddToHelp (" ", helpList)
  363.       THEN
  364.         RETURN FALSE
  365.       END;
  366.       IF ~AddToHelp (cmdHelp^, helpList)
  367.       THEN
  368.         RETURN FALSE
  369.       END;
  370.       IF ~AddToHelp (" ", helpList)
  371.       THEN
  372.         RETURN FALSE
  373.       END;
  374.     END;
  375.     IF hasParms
  376.     THEN
  377.       Lists.ResetList (cmdParms);
  378.       pParm := Lists.NextEntry (cmdParms);
  379.       WHILE pParm # NIL DO
  380.         IF ~AddParmHelp (pParm, helpList) THEN RETURN FALSE END;
  381.         pParm := Lists.NextEntry (cmdParms);
  382.       END;
  383.     END;
  384.   END;
  385.   RETURN TRUE;
  386. END BuildHelp;
  387.  
  388. (*----------------------------------------------------------------------
  389.  * ITK Dialogboxen zusammenbauen
  390.  *----------------------------------------------------------------------*)
  391.  
  392. PROCEDURE SetObjc (objc, typ, x, y, w, h: INTEGER; f, s: BITSET; 
  393.                    spec: ADDRESS);
  394. BEGIN
  395.  Tree[objc].obNext:= -1;
  396.  Tree[objc].obHead:= -1;
  397.  Tree[objc].obTail:= -1;
  398.  Tree[objc].obType:= typ;
  399.  Tree[objc].obFlags:= f;
  400.  Tree[objc].obState:= s;
  401.  Tree[objc].obSpec.address:= spec;
  402.  Tree[objc].obX:= x;
  403.  Tree[objc].obY:= y;
  404.  Tree[objc].obWidth:= w;
  405.  Tree[objc].obHeight:= h;
  406.  MagicAES.ObjcAdd (theTree, Box, objc);
  407.  Tree[Box].obWidth := BinOps.HigherInt (x+w, Tree[Box].obWidth);
  408.  Tree[Box].obHeight := BinOps.HigherInt (y+h, Tree[Box].obHeight);
  409. END SetObjc;
  410.  
  411. PROCEDURE PrepareTree (VAR title: ARRAY OF CHAR);
  412. BEGIN
  413.  theTree := ADR (Tree);
  414.  Tree[Box].obNext:= -1;
  415.  Tree[Box].obHead:= -1;
  416.  Tree[Box].obTail:= -1;
  417.  Tree[Box].obType:= GBOX;
  418.  Tree[Box].obFlags:= {FL3DBAK};
  419.  Tree[Box].obState:= {OUTLINED};
  420.  Tree[Box].obSpec.Box.char:= 0C;
  421.  Tree[Box].obSpec.Box.frame:= 2C;
  422.  (* Tree[Box].obSpec.Box.flags:= {Bit0,Bit11, Bit12}; *)
  423.  Tree[Box].obSpec.Box.flags:= {Bit11, Bit12};
  424.  Tree[Box].obX:= 0;  Tree[Box].obY:= 0;
  425.  Tree[Box].obWidth:= 0;
  426.  Tree[Box].obHeight:= 0;
  427.  SetObjc (Mover, 1119H, 0, 0, 16, 16, {}, {OUTLINED}, Null);
  428.  Tree[Mover].obSpec.Box.char:= 0C;
  429.  Tree[Mover].obSpec.Box.frame:= 1C;
  430.  Tree[Mover].obSpec.Box.flags:= {Bit11, Bit12};
  431.  (* Titelzeile hinzufgen *)
  432.  SetObjc (Header, 131CH, 2 * mtAppl.CharWidth, mtAppl.CharHeight, INTEGER(LENGTH(title)) * mtAppl.CharWidth, 0, {}, {MagicAES.SHADOWED}, ADR(title));
  433.  currObIdx := Header+1;
  434.  tedIdx := 0;
  435.  lastyPos := currObIdx * mtAppl.CharHeight;
  436.  usedKeys := KeySet{'A','O','P'};
  437. END PrepareTree;
  438.  
  439. PROCEDURE CalcCoords (REF text: ARRAY OF CHAR; VAR x, y, w, h: INTEGER);
  440. BEGIN
  441.   h := mtAppl.CharHeight;
  442.   x := mtAppl.CharWidth * 2;
  443.   y := lastyPos + mtAppl.CharHeight;
  444.   lastyPos := y;
  445.   w := mtAppl.CharWidth * INTEGER(LENGTH (text)+4);
  446. END CalcCoords;
  447.  
  448. PROCEDURE CalcCoords2 (REF name: ARRAY OF CHAR; maxLen: INTEGER; VAR x, y, w, h: INTEGER);
  449. BEGIN
  450.   DEC (lastyPos, mtAppl.CharHeight);
  451.   CalcCoords (name, x, y, w, h);
  452.   x := x + w - 2 * mtAppl.CharWidth;
  453.   IF maxLen > 50 
  454.   THEN 
  455.     maxLen := 50;
  456.   END;
  457.   IF maxLen = 0
  458.   THEN 
  459.     maxLen := 50;
  460.   END;
  461.   w := mtAppl.CharWidth * (maxLen + 1);
  462. END CalcCoords2;
  463.  
  464. PROCEDURE CalcEdButCoords (maxLen: INTEGER; VAR x, y, w, h: INTEGER);
  465. BEGIN
  466.   x := x + w + 2 * mtAppl.CharWidth;
  467.   IF maxLen > 50 
  468.   THEN 
  469.     maxLen := 50;
  470.   END;
  471.   IF maxLen = 0
  472.   THEN 
  473.     maxLen := 50;
  474.   END;
  475.   w := mtAppl.CharWidth * (maxLen + 4);
  476. END CalcEdButCoords;
  477.  
  478. PROCEDURE AddShortcut (VAR name: ARRAY OF CHAR);
  479.   VAR l : CARDINAL;
  480.       i : CARDINAL;
  481.       ch: CHAR;
  482. BEGIN
  483.   l := LENGTH (name);
  484.   i := 0; 
  485.   ch := CAP (name[i]);
  486.   WHILE (i < l) & 
  487.         ((ch IN usedKeys) OR (ch < 'A') OR (ch > 'Z')) 
  488.   DO 
  489.     INC (i);
  490.     ch := CAP (name[i]);
  491.   END;
  492.   IF (i < l)
  493.   THEN
  494.     (* freien Shortcut gefunden *)
  495.     INCL (usedKeys, ch);
  496.     MagicStrings.Insert ("[", name, i);
  497.   END;
  498. END AddShortcut;
  499.  
  500. PROCEDURE AddCheckButton (VAR name: ARRAY OF CHAR; threeState: BOOLEAN): INTEGER;
  501. (* Check: Ext 18
  502.  * Three: Ext 23
  503.  *)
  504.  VAR obType : CARDINAL;     (* Vereinigt normalen und erweiterten Objekttyp *)
  505.      x, y, w, h : INTEGER;
  506. BEGIN
  507.   IF threeState
  508.   THEN
  509.     obType := mtDials.ThreeState * 256 + MagicAES.GBUTTON;
  510.   ELSE
  511.     obType := mtDials.SpecButton * 256 + MagicAES.GBUTTON;
  512.   END;
  513.   CalcCoords (name, x, y, w, h);
  514.   AddShortcut (name);
  515.   SetObjc (currObIdx, obType, x, y, w, h, {MagicAES.SELECTABLE}, {}, ADR(name));
  516.   INC (currObIdx);
  517.   RETURN currObIdx - 1;
  518. END AddCheckButton;
  519.  
  520. PROCEDURE AddRadioButton (parent: INTEGER; VAR name: ARRAY OF CHAR): INTEGER;
  521. (* Check: Ext 18
  522.  * Three: Ext 23
  523.  *)
  524.  VAR obType : CARDINAL;     (* Vereinigt normalen und erweiterten Objekttyp *)
  525.      x, y, w, h : INTEGER;
  526. BEGIN
  527.   obType := mtDials.SpecButton * 256 + MagicAES.GBUTTON;
  528.   CalcCoords (name, x, y, w, h);
  529.   AddShortcut (name);
  530.   SetObjc (currObIdx, obType, x, y, w, h, {MagicAES.SELECTABLE, MagicAES.RBUTTON}, {}, ADR(name));
  531.   (* Tree[currObIdx].obHead := parent; *)
  532.   INC (currObIdx);
  533.   RETURN currObIdx - 1;
  534. END AddRadioButton;
  535.  
  536. (*
  537. PROCEDURE AddParent (): INTEGER;
  538. BEGIN
  539.   obType := MagicAES.GIBOX;
  540.   CalcCoords3 (x, y, w, h);
  541.   SetObjc (currObIdx, obType, x, y, w, h, {}, {}, Null);
  542.   INC (currObIdx);
  543.   RETURN currObIdx - 1;
  544. END AddParent;
  545. *)
  546.  
  547. PROCEDURE AddText (VAR name: ARRAY OF CHAR): INTEGER;
  548. (* Check: Ext 18
  549.  * Three: Ext 23
  550.  *)
  551.  VAR obType : CARDINAL;     (* Vereinigt normalen und erweiterten Objekttyp *)
  552.      x, y, w, h : INTEGER;
  553. BEGIN
  554.   obType := MagicAES.GSTRING;
  555.   CalcCoords (name, x, y, w, h);
  556.   SetObjc (currObIdx, obType, x, y, w, h, {}, {}, ADR(name));
  557.   INC (currObIdx);
  558.   RETURN currObIdx - 1;
  559. END AddText;
  560.  
  561. PROCEDURE PrepareEdit (isNum: BOOLEAN; maxLength: INTEGER; REF default: ARRAY OF CHAR;
  562.                        VAR obType: CARDINAL);
  563.   VAR validChar : CHAR;
  564.       i         : INTEGER;
  565. BEGIN
  566.   IF (maxLength = 0) & ~isNum
  567.   THEN
  568.     maxLength := 255;
  569.   ELSIF (maxLength = 0) & isNum
  570.   THEN
  571.     maxLength := 10;
  572.   END;
  573.   IF (maxLength > 50) & ~isNum
  574.   THEN
  575.     obType := mtDials.LongEdit * 256 + MagicAES.GFTEXT;
  576.   ELSE
  577.     obType := MagicAES.GFTEXT;
  578.   END;
  579.   WITH Teds[tedIdx] DO
  580.     ALLOCATE (tePtext, maxLength + 1);
  581.     ALLOCATE (tePvalid, maxLength + 1);
  582.     ALLOCATE (tePtmplt, maxLength + 1);
  583.     teFont := MagicAES.IBM;
  584.     teFontid    := 0;
  585.     teJust      := 0;
  586.     teColor     := INTEGER({Bit7, Bit8});
  587.     teFontsize  := 0;
  588.     teThickness := 0;
  589.     teTxtlen := maxLength;
  590.     teTmplen := maxLength;
  591.     MagicStrings.Assign (default, tePtext^);
  592.     IF isNum
  593.     THEN
  594.       validChar := '9';
  595.     ELSE
  596.       validChar := 'X';
  597.     END;
  598.     FOR i := 0 TO maxLength - 1 DO
  599.       tePvalid^[i] := validChar;
  600.       tePtmplt^[i] := '_';
  601.     END;
  602.     tePvalid^[maxLength] := 0C;
  603.     tePtmplt^[maxLength] := 0C;
  604.   END;
  605. END PrepareEdit;
  606.  
  607. PROCEDURE AddEditField (VAR name: ARRAY OF CHAR; isNum: BOOLEAN; 
  608.                         maxLength: INTEGER; REF default: ARRAY OF CHAR): INTEGER;
  609.   VAR obType : CARDINAL;
  610.       x, y, w, h : INTEGER;
  611. BEGIN
  612.   PrepareEdit (isNum, maxLength, default, obType);
  613.   v.int := AddText (name);
  614.   CalcCoords2 (name, maxLength, x, y, w, h);
  615.  
  616.   SetObjc (currObIdx, obType, x, y, w, h, {MagicAES.EDITABLE}, {}, ADR(Teds[tedIdx]));
  617.   INC (tedIdx);
  618.   INC (currObIdx);
  619.   RETURN currObIdx - 1;
  620. END AddEditField;
  621.  
  622.  
  623. PROCEDURE AddHelpBut(x, y, w, h : INTEGER);
  624. BEGIN
  625.   WITH Teds[tedIdx] DO
  626.     ALLOCATE (tePtext, LENGTH (HelpBut)+1);
  627.     tePvalid := NIL;
  628.     tePtmplt := NIL;
  629.     teFont := MagicAES.SMALL;
  630.     teFontid    := 0;
  631.     teJust      := 2;
  632.     teColor     := INTEGER({Bit7, Bit8, Bit12});
  633.     teFontsize  := 0;
  634.     teThickness := -1;
  635.     teTxtlen := LENGTH (HelpBut);
  636.     teTmplen := 0;
  637.     MagicStrings.Assign (HelpBut, tePtext^);
  638.   END;
  639.   SetObjc (currObIdx, MagicAES.GBOXTEXT, x, y, w, h, {MagicAES.SELECTABLE, MagicAES.Exit, Bit15}, {MagicAES.OUTLINED, MagicAES.SHADOWED}, ADR(Teds[tedIdx]));
  640.   INC (tedIdx);
  641.   helpButIdx := currObIdx;
  642.   INC (currObIdx);
  643. END AddHelpBut;
  644.  
  645. PROCEDURE AddExitButs();
  646.   VAR obType : CARDINAL;
  647.       x, y, w, h : INTEGER;
  648. BEGIN
  649.   (* Hilfe-, Preview-, OK- und Abbruch-Button hinzufgen *)
  650.   (* Es werden zwei Reihen hinzugefgt, in der oberen der Hilfe- 
  651.    * und der OK-Button, jeweils darunter der Preview- und Abbruch-
  652.    * Button. Das sieht dann ungef„hr so aus:
  653.    *
  654.    * |  +------------+                      +-------------+  |
  655.    * |  |   Help     |                      |     OK      |  |
  656.    * |  +------------+                      +-------------+  |
  657.    * |                                                       |
  658.    * |  +------------+                      +-------------+  |
  659.    * |  |  Preview   |                      |   Abbruch   |  |
  660.    * |  +------------+                      +-------------+  |
  661.    * +-------------------------------------------------------+
  662.    *
  663.    *)
  664.   (* Breite um drei vergr”žern  *)  
  665.   Tree[Box].obWidth := Tree[Box].obWidth + 3 * mtAppl.CharWidth;
  666.   obType := mtDials.SpecButton * 256 + MagicAES.GBUTTON;
  667.   (* Position berechnen *)
  668.   h := mtAppl.CharHeight;
  669.   w := mtAppl.CharWidth * INTEGER(LENGTH (CancelBut)+2);
  670.   Tree[Box].obWidth := BinOps.HigherInt (Tree[Box].obWidth, 2 * w + 6 * mtAppl.CharWidth);
  671.   x := 2 * mtAppl.CharWidth;
  672.   y := lastyPos + 2 * mtAppl.CharHeight;
  673.   (* Hilfebutton hinzufgen *)
  674.   AddHelpBut (x, y, w, h);
  675.  
  676.   x := Tree[Box].obWidth - 2 * mtAppl.CharWidth - w;
  677.   SetObjc (currObIdx, obType, x, y, w, h, {MagicAES.SELECTABLE, MagicAES.DEFAULT, MagicAES.Exit}, {}, CADR(OkBut));
  678.   okButIdx := currObIdx;
  679.   INC (currObIdx);
  680.   (* Jetzt Preview- und Abbruch-Button *)
  681.  
  682.   (* Previewbutton *)
  683.   x := 2 * mtAppl.CharWidth;
  684.   y := lastyPos + 4 * mtAppl.CharHeight;
  685.   SetObjc (currObIdx, obType, x, y, w, h, {MagicAES.SELECTABLE, MagicAES.Exit}, {}, CADR(PreviewBut));
  686.   previewButIdx := currObIdx;
  687.   INC (currObIdx);
  688.   (* OK-Button *)
  689.   x := Tree[Box].obWidth - 2 * mtAppl.CharWidth - w;
  690.   SetObjc (currObIdx, obType, x, y, w, h, {MagicAES.SELECTABLE, MagicAES.Exit, Bit14, MagicAES.LASTOB}, {}, CADR(CancelBut));
  691.   cancelButIdx := currObIdx;
  692.   INC (currObIdx);
  693.   Tree[Box].obHeight := lastyPos + 6 * mtAppl.CharHeight;
  694. END AddExitButs;
  695.  
  696. PROCEDURE AddGroupSelect (VAR name: ARRAY OF CHAR; chiefGroup: BOOLEAN;
  697.                           maxLength: INTEGER; REF default: ARRAY OF CHAR): INTEGER;
  698.   VAR obType    : CARDINAL;
  699.       state     : BITSET;
  700.       x, y, w, h : INTEGER;
  701. BEGIN
  702.   (* Button mit Bit fr Groupselect gesetzt *)
  703.   obType := mtDials.SpecButton * 256 + MagicAES.GBUTTON;
  704.   IF chiefGroup
  705.   THEN
  706.     state := {Bit14};
  707.   ELSE
  708.     state := {Bit15};
  709.   END;
  710.   CalcCoords (name, x, y, w, h);
  711.   AddShortcut (name);
  712.   IF (currObIdx > Header+1)
  713.   THEN
  714.     INC (y, mtAppl.CharHeight);
  715.     INC (lastyPos, mtAppl.CharHeight);
  716.   END;
  717.   SetObjc (currObIdx, obType, x, y, w, h, {MagicAES.SELECTABLE, MagicAES.Exit}, state, ADR(name));
  718.   INC (currObIdx);
  719.   
  720.   (* Editfeld hinzufgen *)
  721.   PrepareEdit (FALSE, maxLength, default, obType);
  722.   CalcEdButCoords (maxLength, x, y, w, h);
  723.   SetObjc (currObIdx, obType, x, y, w, h, {MagicAES.EDITABLE}, {}, ADR(Teds[tedIdx]));
  724.   INC (tedIdx);
  725.   INC (currObIdx);
  726.   INC (lastyPos, mtAppl.CharHeight);
  727.   RETURN currObIdx - 1;
  728. END AddGroupSelect;
  729.  
  730. PROCEDURE AddUserSelect (VAR name: ARRAY OF CHAR; maxLength: INTEGER; REF default: ARRAY OF CHAR): INTEGER;
  731.   VAR obType    : CARDINAL;
  732.       x, y, w, h : INTEGER;
  733.       defName   : CatTypes.String255;
  734.       botWdw    : INTEGER;
  735. BEGIN
  736.   (* Button mit Bit fr Groupselect gesetzt *)
  737.   obType := mtDials.SpecButton * 256 + MagicAES.GBUTTON;
  738.   CalcCoords (name, x, y, w, h);
  739.   AddShortcut (name);
  740.   IF (currObIdx > Header+1)
  741.   THEN
  742.     INC (y, mtAppl.CharHeight);
  743.     INC (lastyPos, mtAppl.CharHeight);
  744.   END;
  745.   SetObjc (currObIdx, obType, x, y, w, h, {MagicAES.SELECTABLE, MagicAES.Exit}, {Bit13}, ADR(name));
  746.   INC (currObIdx);
  747.  
  748.   (* Editfeld hinzufgen *)
  749.   PrepareEdit (FALSE, maxLength, default, obType);
  750.  
  751.   CalcEdButCoords (maxLength, x, y, w, h);
  752.   SetObjc (currObIdx, obType, x, y, w, h, {MagicAES.EDITABLE}, {}, ADR(Teds[tedIdx]));
  753.   INC (tedIdx);
  754.   INC (currObIdx);
  755.   INC (lastyPos, mtAppl.CharHeight);
  756.   RETURN currObIdx - 1;
  757. END AddUserSelect;
  758.  
  759. PROCEDURE AddRadioEnums (paramEnums: Lists.List);
  760.   VAR pEnum : pOneEnum;
  761.       count : INTEGER;
  762. BEGIN
  763.   count := Lists.NoOfEntries (paramEnums);
  764.   Lists.ResetList (paramEnums);
  765.   pEnum := Lists.NextEntry (paramEnums);
  766.   WHILE pEnum # NIL DO
  767.     IF count = 1
  768.     THEN
  769.       pEnum^.obLow := AddCheckButton (pEnum^.enumName, FALSE);
  770.     ELSE
  771.       pEnum^.obLow := AddRadioButton (Box, pEnum^.enumName);
  772.     END;
  773.     pEnum := Lists.NextEntry (paramEnums);
  774.   END;
  775. END AddRadioEnums;
  776.  
  777. PROCEDURE CheckEnumValue (REF str: ARRAY OF CHAR): INTEGER;
  778.   VAR count: INTEGER;
  779.       pos  : INTEGER;
  780. BEGIN
  781.   pos := 0;
  782.   count := 0;
  783.   WHILE pos >= 0 DO
  784.     pos := Strings.Pos (":", str, pos);
  785.     IF pos >= 0 THEN INC (pos) END;
  786.     INC (count);
  787.   END;
  788.   RETURN count;
  789. END CheckEnumValue;
  790.  
  791. PROCEDURE AddCheckEnums (paramEnums: Lists.List);
  792.   VAR pEnum : pOneEnum;
  793.       count : INTEGER;
  794. BEGIN
  795.   Lists.ResetList (paramEnums);
  796.   pEnum := Lists.NextEntry (paramEnums);
  797.   WHILE pEnum # NIL DO
  798.     count := CheckEnumValue (pEnum^.enumValue);
  799.     IF count < 3
  800.     THEN 
  801.       pEnum^.obLow := AddCheckButton (pEnum^.enumName, FALSE);
  802.     ELSIF count = 3
  803.     THEN
  804.       pEnum^.obLow := AddCheckButton (pEnum^.enumName, TRUE);
  805.     ELSE
  806.       (* Nicht behandelbar momentan *)
  807.     END;
  808.     pEnum := Lists.NextEntry (paramEnums);
  809.   END;
  810. END AddCheckEnums;
  811.  
  812. PROCEDURE AddParamObjcs (pParam: pOneParam);
  813. BEGIN
  814.   WITH pParam^ DO
  815.     CASE paramType OF
  816.       tpConst   : RETURN; |
  817.       tpEnum    : IF hasEnums 
  818.                   THEN 
  819.                     AddRadioEnums (paramEnum);
  820.                   END; |
  821.       tpEnumSet : IF hasEnums 
  822.                   THEN 
  823.                     AddCheckEnums (paramEnum);
  824.                   END; |
  825.       tpMTDate,
  826.       tpDate    : obLow := AddEditField (paramName, FALSE, 12, paramDflt); |
  827.       tpString,
  828.       tpPassword,
  829.       tpNewPassword:
  830.                   obLow := AddEditField (paramName, FALSE, SHORT(paramMin), paramDflt); |
  831.       tpInt,
  832.       tpRange:    obLow := AddEditField (paramName, TRUE, 10, paramDflt); |
  833.       tpGroup,
  834.       tpChiefGroup:
  835.                   (* Button und dahinter Editfeld *)
  836.                   obLow := AddGroupSelect (paramName, paramType = tpChiefGroup,
  837.                                            SHORT(paramMin), paramDflt); |
  838.       tpUsername:
  839.                   (* Button und dahinter Editfeld *)
  840.                   obLow := AddUserSelect (paramName, SHORT(paramMin), paramDflt); |
  841.     ELSE
  842.     END;
  843.   END;
  844. END AddParamObjcs;
  845.  
  846. PROCEDURE BuildTree (VAR pCmd : pOneCommand);
  847.   VAR pParam    : pOneParam;
  848. BEGIN
  849.   WITH pCmd^ DO
  850.     PrepareTree (cmdName);
  851.     IF hasParms
  852.     THEN
  853.       Lists.ResetList (cmdParms);
  854.       pParam := Lists.NextEntry (cmdParms);
  855.       WHILE pParam # NIL DO
  856.         AddParamObjcs (pParam);
  857.         pParam := Lists.NextEntry (cmdParms);
  858.       END;
  859.     END;
  860.     AddExitButs();
  861.     (* Mover noch verschieben *)
  862.     Tree[Mover].obX:= Tree[Box].obWidth - Tree[Mover].obWidth;
  863.   END;
  864. END BuildTree;
  865.  
  866. PROCEDURE RemoveTree ();
  867. (* Allozierten Speicher fr Editfelder wieder freigeben *)
  868.   VAR i : INTEGER;
  869. BEGIN
  870.   FOR i := 0 TO tedIdx - 1 DO
  871.     WITH Teds[i] DO
  872.       DEALLOCATE (tePtext, 0);
  873.       DEALLOCATE (tePvalid, 0);
  874.       DEALLOCATE (tePtmplt, 0);
  875.     END;
  876.   END;
  877. END RemoveTree;
  878.  
  879. (*----------------------------------------------------------------------
  880.  * ITK Werte aus Dialogbox auslesen 
  881.  *----------------------------------------------------------------------*)
  882.  
  883. PROCEDURE GetEnumValue (idx: INTEGER; REF str: ARRAY OF CHAR; 
  884.                         VAR target: ARRAY OF CHAR);
  885.   VAR count     : INTEGER;
  886.       lastPos   : INTEGER;
  887.       pos       : INTEGER;
  888.       val       : CatTypes.String255;
  889. BEGIN
  890.   lastPos := 0;
  891.   pos := 0;
  892.   count := 0;
  893.   WHILE (pos >= 0) DO
  894.     pos := Strings.Pos (":", str, lastPos);
  895.     IF (count = idx) & (pos > 0)
  896.     THEN
  897.       MagicStrings.Copy (str, lastPos, pos - lastPos, val);
  898.       MagicStrings.Append (val, target);
  899.       RETURN
  900.     END;
  901.     IF (pos < 0) & (count = idx)
  902.     THEN
  903.       (* letzter Parameter oder nur ein Wert *)
  904.       MagicStrings.Copy (str, lastPos, INTEGER(LENGTH (str)) - lastPos, val);
  905.       MagicStrings.Append (val, target);
  906.       (* MagicStrings.Append (str, target); *)
  907.       RETURN
  908.     END;
  909.     lastPos := pos+1;
  910.     INC (count);
  911.   END;
  912. END GetEnumValue;
  913.  
  914. PROCEDURE CheckRadioEnums (paramEnums: Lists.List; VAR str: ARRAY OF CHAR): BOOLEAN;
  915.   VAR pEnum : pOneEnum;
  916.       count : INTEGER;
  917. BEGIN
  918.   count := Lists.NoOfEntries (paramEnums);
  919.   Lists.ResetList (paramEnums);
  920.   pEnum := Lists.NextEntry (paramEnums);
  921.   WHILE pEnum # NIL DO
  922.     IF mtUtils.InState (theTree, pEnum^.obLow, MagicAES.SELECTED)
  923.     THEN
  924.       (* Ersten Wert aus Aufz„hlung nehmen! *)
  925.       GetEnumValue (0, pEnum^.enumValue, str);
  926.       RETURN TRUE;
  927.     ELSIF count = 1
  928.     THEN
  929.       (* Zweiten Wert aus Aufz„hlung nehmen! *)
  930.       GetEnumValue (1, pEnum^.enumValue, str);
  931.       RETURN TRUE;
  932.     END;
  933.     pEnum := Lists.NextEntry (paramEnums);
  934.   END;
  935.   (* Hier kommen wir nur hier, wenn keiner selektiert ist *)
  936.   RETURN count = 1;
  937. END CheckRadioEnums;
  938.  
  939. PROCEDURE CheckCheckEnums (paramEnums: Lists.List; VAR str: ARRAY OF CHAR): BOOLEAN;
  940.   VAR pEnum : pOneEnum;
  941.       count : INTEGER;
  942.       oneSet: BOOLEAN;
  943.       value : INTEGER;
  944. BEGIN
  945.   Lists.ResetList (paramEnums);
  946.   oneSet := FALSE;
  947.   pEnum := Lists.NextEntry (paramEnums);
  948.   WHILE pEnum # NIL DO
  949.     count := CheckEnumValue (pEnum^.enumValue);
  950.     IF count < 3
  951.     THEN
  952.       IF mtUtils.InState (theTree, pEnum^.obLow, MagicAES.SELECTED)
  953.       THEN
  954.         GetEnumValue (0, pEnum^.enumValue, str);
  955.         oneSet := TRUE;
  956.       END;
  957.     ELSIF count = 3
  958.     THEN
  959.       value := mtUtils.GetThreeState (theTree, pEnum^.obLow);
  960.       IF value = mtUtils.CLEAR
  961.       THEN
  962.         (* zweiten Wert aus Enum nehmen *)
  963.         GetEnumValue (1, pEnum^.enumValue, str);
  964.         oneSet := TRUE;
  965.       ELSIF value = mtUtils.SETNEW
  966.       THEN
  967.         (* ersten Wert aus Enum nehmen *)
  968.         GetEnumValue (0, pEnum^.enumValue, str);
  969.         oneSet := TRUE;
  970.       END;
  971.     ELSE
  972.       (* Nicht behandelbar momentan *)
  973.     END;
  974.     pEnum := Lists.NextEntry (paramEnums);
  975.   END;
  976.   RETURN oneSet;
  977. END CheckCheckEnums;
  978.  
  979. PROCEDURE GetParam (pParm: pOneParam; VAR str: ARRAY OF CHAR): BOOLEAN;
  980.   VAR bRes  : BOOLEAN;
  981.       value : CatTypes.String255;
  982.       dt    : ConvertDate.Date;
  983.       temp  : CatTypes.String127;
  984.       lIntVal   : LONGINT;
  985.       pos   : CARDINAL;
  986.       pName : CatTypes.String127;
  987. BEGIN
  988.   WITH pParm^ DO
  989.     CASE paramType OF
  990.       tpConst   : (* Konstanten Teil bernehmen *)
  991.                   MagicStrings.Append (paramDflt, str);
  992.                   RETURN TRUE; |
  993.       tpEnum    : IF hasEnums 
  994.                   THEN
  995.                     bRes := CheckRadioEnums (paramEnum, str);
  996.                     IF ~bRes
  997.                     THEN
  998.                       (* Fehlermeldung *)
  999.                       StripShortcut (paramName, pName);
  1000.                       MTE.InfoAlert (eEnumCheck1, pName, eEnumCheck2);
  1001.                       RETURN FALSE;
  1002.                     END;
  1003.                   END;
  1004.                   RETURN TRUE; |
  1005.       tpEnumSet : IF hasEnums 
  1006.                   THEN 
  1007.                     bRes := CheckCheckEnums (paramEnum, str);
  1008.                     IF ~bRes
  1009.                     THEN
  1010.                       (* Fehlermeldung *)
  1011.                       StripShortcut (paramName, pName);
  1012.                       MTE.InfoAlert (eEnumCheck1, pName, eEnumCheck2);
  1013.                       RETURN FALSE;
  1014.                     END;
  1015.                   END; 
  1016.                   RETURN TRUE; |
  1017.       tpMTDate,
  1018.       tpDate    : (* Editfeld auslesen *)
  1019.                   mtUtils.ObjcString (theTree, obLow, value);
  1020.                   IF (value[0] = 0C)
  1021.                   THEN
  1022.                     IF ~optional
  1023.                     THEN
  1024.                       (* Fehlermeldung *)
  1025.                       StripShortcut (paramName, pName);
  1026.                       MTE.InfoAlert (eEmptyParm1, pName, eEmptyParm2);
  1027.                       RETURN FALSE;
  1028.                     END;
  1029.                   ELSIF ~ConvertDate.DateOk (value)
  1030.                   THEN
  1031.                     (* Fehlermeldung *)
  1032.                     StripShortcut (paramName, pName);
  1033.                     MTE.InfoAlert (eDateAlt1, pName, eDateAlt2);
  1034.                     RETURN FALSE;
  1035.                   ELSE
  1036.                     (* Datum konvertieren *)
  1037.                     IF paramType = tpMTDate
  1038.                     THEN
  1039.                       ConvertDate.StrToMTDate (value, temp);
  1040.                     ELSE
  1041.                       ConvertDate.TextToDate (value, dt, v.bool);
  1042.                       ConvertDate.DateToText (dt, "DD.MM.YYYY", temp);
  1043.                     END;
  1044.                     MagicStrings.Append (temp, str);
  1045.                   END;
  1046.                   RETURN TRUE; |
  1047.       tpUsername,
  1048.       tpGroup,
  1049.       tpChiefGroup,
  1050.       tpString,
  1051.       tpPassword,
  1052.       tpNewPassword:
  1053.                   mtUtils.ObjcString (theTree, obLow, value);
  1054.                   Strings.DelLeadingBlanks (value);
  1055.                   Strings.DelTrailingBlanks (value);
  1056.                   IF (value[0] = 0C)
  1057.                   THEN
  1058.                     IF ~optional
  1059.                     THEN
  1060.                       (* Fehlermeldung *)
  1061.                       StripShortcut (paramName, pName);
  1062.                       MTE.InfoAlert (eEmptyParm1, pName, eEmptyParm2);
  1063.                       RETURN FALSE;
  1064.                     END;
  1065.                   ELSE
  1066.                     MagicStrings.Append (value, str);
  1067.                   END;
  1068.                   RETURN TRUE; |
  1069.       tpInt,
  1070.       tpRange:    mtUtils.ObjcString (theTree, obLow, value);
  1071.                   Strings.DelBlanks (value);
  1072.                   IF (value[0] = 0C)
  1073.                   THEN
  1074.                     IF ~optional
  1075.                     THEN
  1076.                       (* Fehlermeldung *)
  1077.                       StripShortcut (paramName, pName);
  1078.                       MTE.InfoAlert (eEmptyParm1, pName, eEmptyParm2);
  1079.                       RETURN FALSE;
  1080.                     END;
  1081.                   ELSE
  1082.                     pos := 0;
  1083.                     lIntVal := StrConv.StrToLInt (value, pos, v.bool);
  1084.                     IF paramType = tpRange
  1085.                     THEN
  1086.                       IF (lIntVal < paramMin) OR (lIntVal > paramMax)
  1087.                       THEN
  1088.                         (* Fehlermeldung *)
  1089.                         StripShortcut (paramName, pName);
  1090.                         MagicStrings.Assign (eRangeAlt1, value);
  1091.                         MagicStrings.Append (pName, value);
  1092.                         MagicStrings.Append (eRangeAlt2, value);
  1093.                         MagicStrings.Append (StrConv.IntToStr (paramMin, 0), value);
  1094.                         MagicStrings.Append (eRangeAlt3, value);
  1095.                         MagicStrings.Append (StrConv.IntToStr (paramMax, 0), value);
  1096.                         MagicStrings.Append (eRangeAlt4, value);
  1097.                         
  1098.                         MTE.info (value);
  1099.                         RETURN FALSE;
  1100.                       END;
  1101.                     END;
  1102.                     IF lIntVal >= 0
  1103.                     THEN
  1104.                       MagicStrings.Assign ("+", value);
  1105.                     ELSE
  1106.                       MagicStrings.Assign ("", value);
  1107.                     END;
  1108.                     MagicStrings.Append (StrConv.IntToStr (lIntVal, 0), value);
  1109.                     MagicStrings.Append (value, str);
  1110.                   END;
  1111.                   RETURN TRUE; |
  1112.     ELSE
  1113.     END;
  1114.   END;
  1115.   RETURN TRUE;
  1116. END GetParam;
  1117.  
  1118. PROCEDURE WriteCmdToFile (REF str: ARRAY OF CHAR);
  1119.   VAR   fName   : CatTypes.String255;
  1120.         fHdl    : mtTextfiles.TEXTFILE;
  1121. BEGIN
  1122.   IF str[0] = 0C THEN RETURN END;
  1123.   MagicStrings.Assign (MTPaths.MessagePath, fName);
  1124.   MagicStrings.Append (CatTypes.userCmdFile, fName);
  1125.   IF mtTextfiles.OpenTextfile (fName, mtTextfiles.APPEND, 512, fHdl)
  1126.   OR mtTextfiles.OpenTextfile (fName, mtTextfiles.WRITE, 512, fHdl)
  1127.   THEN
  1128.     mtTextfiles.WriteChar (fHdl, ':');
  1129.     mtTextfiles.WriteLine (fHdl, str);
  1130.     mtTextfiles.WriteLn (fHdl);
  1131.     mtTextfiles.CloseTextfile (fHdl);
  1132.   ELSE
  1133.     MTE.InfoAlert (MTE.noFile1, fName, MTE.noFile3);
  1134.   END;
  1135. END WriteCmdToFile;
  1136.  
  1137. PROCEDURE GetValues (pCmd: pOneCommand; doWrite: BOOLEAN; preview: BOOLEAN): BOOLEAN;
  1138.   VAR pParm : pOneParam;
  1139.       str   : CatTypes.String1023;
  1140.       tmp   : CatTypes.String255;
  1141. BEGIN
  1142.   (* Parameter und Objekte auslesen und prfen *)
  1143.   MagicStrings.Assign ("",str);
  1144.   WITH pCmd^ DO
  1145.     IF hasParms
  1146.     THEN
  1147.       Lists.ResetList (cmdParms);
  1148.       pParm := Lists.NextEntry (cmdParms);
  1149.       WHILE pParm # NIL DO
  1150.         IF ~GetParam (pParm, str)
  1151.         THEN
  1152.           RETURN FALSE
  1153.         END;
  1154.         pParm := Lists.NextEntry (cmdParms);
  1155.       END;
  1156.       IF doWrite
  1157.       THEN
  1158.         IF cmdType = tcConfig
  1159.         THEN
  1160.           (* Abfragen, ob es gespeichert oder nur einmal geschrieben werden soll *)
  1161.           MagicStrings.Assign (eSaveCmd1, tmp);
  1162.           MagicStrings.Append (cmdName, tmp);
  1163.           MagicStrings.Append (eSaveCmd2, tmp);
  1164.           v.int := mtAlerts.Alert (1, tmp);
  1165.           IF v.int = 1
  1166.           THEN
  1167.             (* Sichern in CATUSER.INF *)
  1168.             MagicStrings.Assign (cItkCmd, tmp);
  1169.             MagicStrings.Append (StrConv.IntToStr (cmdIdent, 0), tmp);
  1170.             v.bool := ConfVars.SetConfigString (tmp, str);
  1171.             MagicStrings.Assign (cItkCmdVersion, tmp);
  1172.             MagicStrings.Append (StrConv.IntToStr (cmdIdent, 0), tmp);
  1173.             v.bool := ConfVars.SetConfigInt (tmp, cmdVersion);
  1174.             ConfVars.GetConfDefInt (cItkCmdMax, v.int, -1);
  1175.             IF v.int < cmdIdent
  1176.             THEN
  1177.               v.bool := ConfVars.SetConfigInt (cItkCmdMax, cmdIdent);
  1178.             END;
  1179.             IF ~UserInformation.UserBLK.autosave
  1180.             THEN
  1181.               v.int := mtAlerts.Alert (1, eSaveConfig);
  1182.               IF v.int = 1
  1183.               THEN
  1184.                 CatUtil.WriteUserBlock();
  1185.               END;
  1186.             END;
  1187.           ELSIF v.int = 2
  1188.           THEN
  1189.             WriteCmdToFile (str);
  1190.           END;
  1191.         ELSE
  1192.           WriteCmdToFile (str);
  1193.         END;
  1194.       END;
  1195.       IF preview
  1196.       THEN
  1197.         MTE.InfoAlert (ePreview1, str, ePreview2);
  1198.       END;
  1199.     END;
  1200.   END;
  1201.   RETURN TRUE;
  1202. END GetValues;
  1203.  
  1204. (*----------------------------------------------------------------------
  1205.  * Parser fr das ITK 
  1206.  *----------------------------------------------------------------------*)
  1207.  
  1208. PROCEDURE ParseDataType (REF typeStr : ARRAY OF CHAR; VAR param: OneParam): BOOLEAN;
  1209.   VAR pos : CARDINAL;
  1210. BEGIN
  1211.   pos := 1;
  1212.   CASE typeStr[0] OF 
  1213.       'A' :   param.paramType := tpEnum; |
  1214.       'M' :   param.paramType := tpEnumSet; |
  1215.       'D' :   param.paramType := tpMTDate; |
  1216.       'd' :   param.paramType := tpDate; |
  1217.       'S',
  1218.       'P',
  1219.       'p' :   CASE typeStr[0] OF
  1220.                 'S' : param.paramType := tpString; |
  1221.                 'P' : param.paramType := tpPassword; |
  1222.                 'p' : param.paramType := tpNewPassword; |
  1223.               ELSE
  1224.               END;
  1225.               (* Maxl„nge auslesen *)
  1226.               param.paramMin := StrConv.StrToLInt (typeStr, pos, v.bool); |
  1227.       'U' :   param.paramType := tpUsername; |
  1228.       'I' :   IF Strings.Pos (',', typeStr, pos) > 0
  1229.               THEN
  1230.                 param.paramType := tpRange;
  1231.                 (* Direkt aufsplitten und Min und Max rauslesen *)
  1232.                 param.paramMin := StrConv.StrToLInt (typeStr, pos, v.bool);
  1233.                 INC (pos);    (* Komma berspringen *)
  1234.                 param.paramMax := StrConv.StrToLInt (typeStr, pos, v.bool);
  1235.               ELSE
  1236.                 param.paramType := tpInt; 
  1237.               END; |
  1238.       'G' :   param.paramType := tpGroup; |
  1239.       'g' :   param.paramType := tpChiefGroup; |
  1240.   ELSE
  1241.     globErr := errDataType;
  1242.     RETURN FALSE;
  1243.   END;
  1244.   param.optional := typeStr[pos] = 'o'; 
  1245.   RETURN TRUE;
  1246. END ParseDataType;
  1247.  
  1248. PROCEDURE WriteParam (VAR cConstant, cDataType: ARRAY OF CHAR;
  1249.                       VAR cParam: OneParam;
  1250.                       VAR cCmd  : OneCommand;
  1251.                       VAR paramDataDa : BOOLEAN): BOOLEAN;
  1252.   VAR pParam  : pOneParam;
  1253. BEGIN
  1254.   IF cConstant[0] # ""
  1255.   THEN
  1256.     cParam.paramType := tpConst;
  1257.     MagicStrings.Assign (cConstant, cParam.paramDflt);
  1258.   END;
  1259.   ALLOCATE (pParam, TSIZE (OneParam));
  1260.   IF pParam = NIL
  1261.   THEN
  1262.     RETURN FALSE
  1263.   END;
  1264.   (* Inhalt kopieren *)
  1265.   pParam^ := cParam;
  1266.   (* An Liste anh„ngen *)
  1267.   Lists.AppendEntry (cCmd.cmdParms, pParam, v.bool);
  1268.   (* Daten zurcksetzen *)
  1269.   paramDataDa := FALSE;
  1270.   MagicStrings.Assign ("", cConstant);
  1271.   MagicStrings.Assign ("", cDataType);
  1272.   MagicStrings.Assign ("", cParam.paramName);
  1273.   MagicStrings.Assign ("", cParam.paramDflt);
  1274.   cParam.paramMin := 0;
  1275.   cParam.paramMax := 0;
  1276.   cParam.optional := FALSE;
  1277.   cParam.paramHelp := NIL;
  1278.   cParam.hasEnums := FALSE;
  1279.   (* Und Returncode von AppendEntry zurckgeben *)
  1280.   RETURN ~v.bool;
  1281. END WriteParam;
  1282.  
  1283. PROCEDURE WriteEnumData (VAR param: OneParam; VAR enum: OneEnum;
  1284.                          VAR enumDataDa: BOOLEAN): BOOLEAN;
  1285.   VAR pEnum   : pOneEnum;
  1286. BEGIN
  1287.   ALLOCATE (pEnum, TSIZE (OneEnum));
  1288.   IF pEnum = NIL
  1289.   THEN
  1290.     RETURN FALSE;
  1291.   END;
  1292.   (* Inhalt kopieren *)
  1293.   pEnum^ := enum;
  1294.   (* An Liste anh„ngen *)
  1295.   Lists.AppendEntry (param.paramEnum, pEnum, v.bool);
  1296.   MagicStrings.Assign ("", enum.enumName);
  1297.   MagicStrings.Assign ("", enum.enumValue);
  1298.   enumDataDa := FALSE;
  1299.   RETURN ~v.bool;
  1300. END WriteEnumData;
  1301.  
  1302. PROCEDURE IsInternalCmd (VAR cCmd : OneCommand): BOOLEAN;
  1303.   VAR i : INTEGER;
  1304. BEGIN
  1305.   FOR i := 0 TO maxInternalCmds - 1 DO
  1306.     IF (cCmd.cmdIdent = internalCmds[i].intIdent)
  1307.     &  (cCmd.cmdVersion = internalCmds[i].intVersion)
  1308.     THEN
  1309.       RETURN TRUE;
  1310.     END;
  1311.   END;
  1312.   RETURN FALSE;
  1313. END IsInternalCmd;
  1314.  
  1315. PROCEDURE WriteCmd (VAR cmd: OneCommand; 
  1316.                     VAR cmdDataDa : BOOLEAN): BOOLEAN;
  1317.  VAR pCmd : pOneCommand;
  1318. BEGIN
  1319.   IF IsInternalCmd (cmd)
  1320.   THEN
  1321.     (* Speicher freigeben *)
  1322.     IF cmd.hasParms
  1323.     THEN
  1324.       DeleteSimpleList (cmd.cmdParms, TRUE, delParam);
  1325.     END;
  1326.     IF cmd.cmdHelp # NIL
  1327.     THEN
  1328.       DEALLOCATE (cmd.cmdHelp, 0);
  1329.     END;
  1330.     v.bool := FALSE;
  1331.   ELSE
  1332.     ALLOCATE (pCmd, TSIZE (OneCommand));
  1333.     IF pCmd = NIL
  1334.     THEN 
  1335.       RETURN FALSE
  1336.     END;
  1337.     (* Inhalt kopieren *)
  1338.     pCmd^ := cmd;
  1339.     pCmd^.selected := FALSE;
  1340.     (* An Liste anh„ngen *)
  1341.     Lists.AppendEntry (cmds, pCmd, v.bool);
  1342.   END;
  1343.   MagicStrings.Assign ("", cmd.cmdName);
  1344.   cmd.cmdVersion := 0;
  1345.   cmd.hasParms := FALSE;
  1346.   cmd.cmdHelp := NIL;
  1347.   
  1348.   cmdDataDa := FALSE;
  1349.   RETURN ~v.bool;
  1350. END WriteCmd;
  1351.  
  1352. PROCEDURE ParseITK(file: mtTextfiles.TEXTFILE): BOOLEAN;
  1353.   VAR   cDataType,
  1354.         cConstant   : CatTypes.String255;
  1355.         newPtr      : MidTextPtr;
  1356.         cParam      : OneParam;
  1357.         cEnum       : OneEnum;
  1358.         cCmd        : OneCommand;
  1359.         
  1360.         cmdDataDa   : BOOLEAN;
  1361.         enumDataDa  : BOOLEAN;
  1362.         paramDataDa : BOOLEAN;
  1363.         
  1364.         pos         : CARDINAL;
  1365.         scrap       : CatTypes.String255;
  1366.         cLineType   : CHAR;
  1367.  
  1368. BEGIN
  1369.  
  1370.   paramDataDa := FALSE;
  1371.   enumDataDa := FALSE;
  1372.   cmdDataDa := FALSE;
  1373.  
  1374.   cCmd.cmdHelp := NIL;
  1375.   cCmd.hasParms := FALSE;
  1376.   cParam.paramHelp := NIL;
  1377.   cParam.hasEnums := FALSE;
  1378.   
  1379.   WHILE ~mtTextfiles.EndofText (file) DO
  1380.     mtTextfiles.ReadLine (file, scrap);
  1381.     mtTextfiles.ReadLn (file);
  1382.     (* Erstes Zeichen extrahieren und l”schen *)
  1383.     cLineType := scrap[0];
  1384.     MagicStrings.Delete (scrap, 0, 1);
  1385.     CASE cLineType OF
  1386.       '#' : (* ID des Kommandos *)
  1387.             IF enumDataDa
  1388.             THEN
  1389.               IF ~WriteEnumData (cParam, cEnum, enumDataDa)
  1390.               THEN
  1391.                 RETURN FALSE;
  1392.               END;
  1393.             END;
  1394.             IF paramDataDa
  1395.             THEN
  1396.               IF ~WriteParam(cConstant, cDataType, cParam, cCmd, paramDataDa)
  1397.               THEN
  1398.                 RETURN FALSE;
  1399.               END;
  1400.             END;
  1401.             IF cmdDataDa
  1402.             THEN
  1403.               IF ~WriteCmd (cCmd, cmdDataDa)
  1404.               THEN 
  1405.                 RETURN FALSE;
  1406.               END;
  1407.             END;
  1408.             pos := 0;
  1409.             cCmd.cmdIdent := StrConv.StrToInt (scrap, pos, v.bool); 
  1410.             cmdDataDa := TRUE; |
  1411.       'N' : (* Name des Kommandos *)
  1412.             MagicStrings.Assign (scrap, cCmd.cmdName); |
  1413.             
  1414.       'V' : (* Version des Kommandos *)
  1415.             pos := 0;
  1416.             cCmd.cmdVersion := StrConv.StrToInt (scrap, pos, v.bool); |
  1417.             
  1418.       'H' : IF cCmd.cmdHelp = NIL
  1419.             THEN 
  1420.               ALLOCATE (cCmd.cmdHelp, LENGTH(scrap)+1);
  1421.               IF cCmd.cmdHelp # NIL
  1422.               THEN
  1423.                 MagicStrings.Assign (scrap, cCmd.cmdHelp^);
  1424.               ELSE
  1425.                 RETURN FALSE;
  1426.               END;
  1427.             ELSE
  1428.               ALLOCATE (newPtr, LENGTH (cCmd.cmdHelp^)+LENGTH (scrap) + 2);
  1429.               IF newPtr # NIL
  1430.               THEN
  1431.                 (* String zusammensetzen *)
  1432.                 MagicStrings.Assign (cCmd.cmdHelp^, newPtr^);
  1433.                 MagicStrings.Append (" ", newPtr^);
  1434.                 MagicStrings.Append (scrap, newPtr^);
  1435.                 DEALLOCATE (cCmd.cmdHelp, 0);
  1436.                 cCmd.cmdHelp := newPtr;
  1437.               ELSE
  1438.                 RETURN FALSE;
  1439.               END;
  1440.             END; |
  1441.       'T' : (* Kommandotyp *)
  1442.             CASE scrap[0] OF
  1443.                 'K' :   cCmd.cmdType := tcConfig; |
  1444.                 'E' :   cCmd.cmdType := tcSingle; |
  1445.                 'B' :   cCmd.cmdType := tcMultiple; |
  1446.             ELSE
  1447.               cCmd.cmdType := tcSingle;
  1448.             END; |
  1449.             
  1450.       'C' : (* Konstanter Syntax-Teil, neuer Parameter *)
  1451.             IF enumDataDa
  1452.             THEN
  1453.               IF ~WriteEnumData (cParam, cEnum, enumDataDa)
  1454.               THEN
  1455.                 RETURN FALSE;
  1456.               END;
  1457.             END;
  1458.             IF paramDataDa
  1459.             THEN
  1460.               IF ~WriteParam(cConstant, cDataType, cParam, cCmd, paramDataDa)
  1461.               THEN
  1462.                 RETURN FALSE;
  1463.               END;
  1464.             ELSE
  1465.               Lists.CreateList (cCmd.cmdParms, v.bool);
  1466.               IF v.bool
  1467.               THEN
  1468.                 RETURN FALSE;
  1469.               END;
  1470.               cCmd.hasParms := TRUE;
  1471.             END;
  1472.             MagicStrings.Assign (scrap, cConstant); 
  1473.             paramDataDa := TRUE; |
  1474.             
  1475.       'F' : (* Variabler Parameter, Datentyp *)
  1476.             IF enumDataDa
  1477.             THEN
  1478.               IF ~WriteEnumData (cParam, cEnum, enumDataDa)
  1479.               THEN
  1480.                 RETURN FALSE;
  1481.               END;
  1482.             END;
  1483.             IF paramDataDa
  1484.             THEN
  1485.               IF ~WriteParam(cConstant, cDataType, cParam, cCmd, paramDataDa)
  1486.               THEN
  1487.                 RETURN FALSE;
  1488.               END;
  1489.             ELSE
  1490.               Lists.CreateList (cCmd.cmdParms, v.bool);
  1491.               IF v.bool
  1492.               THEN
  1493.                 RETURN FALSE;
  1494.               END;
  1495.               cCmd.hasParms := TRUE;
  1496.             END;
  1497.             MagicStrings.Assign (scrap, cDataType); 
  1498.             IF ~ParseDataType (cDataType, cParam)
  1499.             THEN
  1500.               lastCmd := cCmd.cmdIdent;
  1501.               RETURN FALSE;
  1502.             END;
  1503.             paramDataDa := TRUE; |
  1504.  
  1505.       (* Einzelne Teile eines Parameters *)
  1506.       'K' : (* Name des Parameters *)
  1507.             MagicStrings.Assign (scrap, cParam.paramName); |
  1508.             
  1509.       'D' : (* Defaultwert des Parameters *)
  1510.             MagicStrings.Assign (scrap, cParam.paramDflt); |
  1511.             
  1512.       'L' : (* Hilfe zu einem Parameter *)
  1513.             IF cParam.paramHelp = NIL
  1514.             THEN 
  1515.               ALLOCATE (cParam.paramHelp, LENGTH(scrap)+1);
  1516.               IF cParam.paramHelp # NIL
  1517.               THEN
  1518.                 MagicStrings.Assign (scrap, cParam.paramHelp^);
  1519.               ELSE
  1520.                 RETURN FALSE;
  1521.               END;
  1522.             ELSE
  1523.               ALLOCATE (newPtr, LENGTH (cParam.paramHelp^)+LENGTH (scrap) + 2);
  1524.               IF newPtr # NIL
  1525.               THEN
  1526.                 (* String zusammensetzen *)
  1527.                 MagicStrings.Assign (cParam.paramHelp^, newPtr^);
  1528.                 MagicStrings.Append (" ", newPtr^);
  1529.                 MagicStrings.Append (scrap, newPtr^);
  1530.                 DEALLOCATE (cParam.paramHelp, 0);
  1531.                 cParam.paramHelp := newPtr;
  1532.               ELSE
  1533.                 RETURN FALSE;
  1534.               END;
  1535.             END; |
  1536.       'A' : (* Aufz„hlungsteil des Parameters *)
  1537.             IF enumDataDa
  1538.             THEN
  1539.               IF ~WriteEnumData (cParam, cEnum, enumDataDa)
  1540.               THEN
  1541.                 RETURN FALSE;
  1542.               END;
  1543.             ELSE
  1544.               Lists.CreateList (cParam.paramEnum, v.bool);
  1545.               IF v.bool
  1546.               THEN 
  1547.                 RETURN FALSE;
  1548.               END;
  1549.               cParam.hasEnums := TRUE;
  1550.             END;
  1551.             MagicStrings.Assign (scrap, cEnum.enumValue); 
  1552.             enumDataDa := TRUE; |
  1553.       'B' : (* Kurzbeschreibung eines Enumwertes *)
  1554.             MagicStrings.Assign (scrap, cEnum.enumName); |
  1555.     ELSE
  1556.     END;
  1557.   END;
  1558.   IF enumDataDa
  1559.   THEN
  1560.     IF ~WriteEnumData (cParam, cEnum, enumDataDa)
  1561.     THEN
  1562.       RETURN FALSE;
  1563.     END;
  1564.   END;
  1565.   IF paramDataDa
  1566.   THEN
  1567.     IF ~WriteParam(cConstant, cDataType, cParam, cCmd, paramDataDa)
  1568.     THEN
  1569.       RETURN FALSE;
  1570.     END;
  1571.   END;
  1572.   IF cmdDataDa
  1573.   THEN
  1574.     IF ~WriteCmd (cCmd, cmdDataDa)
  1575.     THEN 
  1576.       RETURN FALSE;
  1577.     END;
  1578.   END;
  1579.   RETURN TRUE;
  1580. END ParseITK;
  1581.   
  1582. PROCEDURE FreeCmdList ();
  1583. BEGIN
  1584.   (* Liste wieder entfernen *)
  1585.   DeleteSimpleList (cmds, TRUE, delCmd);
  1586. END FreeCmdList;
  1587.  
  1588. PROCEDURE InitCmdList (): BOOLEAN;
  1589.   VAR file  : mtTextfiles.TEXTFILE;
  1590.       fname : CatTypes.String255;
  1591. BEGIN
  1592.   Lists.CreateList (cmds, v.bool);
  1593.   IF v.bool
  1594.   THEN
  1595.     MTE.noMemAlert();
  1596.     RETURN FALSE;
  1597.   END;
  1598.   IF ~Infofiles.GetInfoFilename ('ITK',fname)
  1599.   THEN
  1600.     MTE.info (noITKAlert);
  1601.     RETURN FALSE;
  1602.   END;
  1603.   IF mtTextfiles.OpenTextfile (fname, mtTextfiles.READ, 32767, file)
  1604.   THEN
  1605.     globErr := errMemErr;
  1606.     IF ~ParseITK (file)
  1607.     THEN
  1608.       mtTextfiles.CloseTextfile (file);
  1609.       CASE globErr OF
  1610.         errMemErr   : MTE.noMemAlert(); |
  1611.         errDataType : MTE.numAlert (lastCmd, eDataType); |
  1612.       ELSE
  1613.         MTE.info (eUnknown);
  1614.       END;
  1615.       (* Bisher allozierten Kram wieder freigeben *)
  1616.       FreeCmdList();
  1617.       RETURN FALSE;
  1618.     END;
  1619.     mtTextfiles.CloseTextfile (file);
  1620.   ELSE
  1621.     MTE.InfoAlert (MTE.noFile1, fname, MTE.noFile4);
  1622.     RETURN FALSE;
  1623.   END;
  1624.   
  1625.   RETURN TRUE;
  1626. END InitCmdList;
  1627.  
  1628. (* Userinterface *)
  1629.  
  1630. PROCEDURE lineToStr (entry, env : ADDRESS; VAR str : ARRAY OF CHAR);
  1631.   VAR pCmd : pOneCommand;
  1632. BEGIN
  1633.   pCmd := entry;
  1634.   IF pCmd = NIL THEN RETURN END;
  1635.   MagicStrings.Assign (pCmd^.cmdName, str);
  1636. END lineToStr;
  1637.  
  1638. PROCEDURE selEntry (entry, env: ADDRESS; line : INTEGER): BOOLEAN;
  1639.   VAR pCmd : pOneCommand;
  1640. BEGIN
  1641.   pCmd := entry;
  1642.   IF pCmd = NIL THEN RETURN FALSE END;
  1643.   pCmd^.selected := ~pCmd^.selected;
  1644.   RETURN FALSE;
  1645. END selEntry;
  1646.  
  1647. PROCEDURE isSelected (entry, env : ADDRESS) : BOOLEAN;
  1648.   VAR pCmd : pOneCommand;
  1649. BEGIN
  1650.   pCmd := entry;
  1651.   IF pCmd = NIL THEN RETURN FALSE END;
  1652.   RETURN pCmd^.selected;
  1653. END isSelected;
  1654.  
  1655. PROCEDURE isEnabled (entry, env : ADDRESS) : BOOLEAN;
  1656. BEGIN
  1657.   RETURN TRUE
  1658. END isEnabled;
  1659.  
  1660. PROCEDURE countEntries ( l : ADDRESS; VAR ll: LONGINT; VAR ww: INTEGER);
  1661.  VAR lp     : POINTER TO Lists.List;
  1662. BEGIN
  1663.   lp := l;
  1664.   ww := globalLength * mtAppl.CharWidth;
  1665.   ll := VAL (LONGINT, Lists.NoOfEntries (lp^));
  1666. END countEntries;
  1667.  
  1668. VAR  tr     : mtUtils.tObjcTree;
  1669.      mTree  : ARRAY [0..1] OF MagicAES.OBJECT;
  1670.      mTed   : MagicAES.TEDINFO;
  1671.      mText  : ARRAY [0..255] OF CHAR;
  1672.  
  1673. PROCEDURE drawCmdEntry (entry, env : ADDRESS; x, y : INTEGER;
  1674.                          offset : INTEGER; clip   : GrafBase.Rectangle);
  1675.  
  1676. CONST spaceString = "                                                   ";
  1677.   VAR pCmd : pOneCommand;
  1678. BEGIN
  1679.   tr^[0].obX := x;
  1680.   tr^[0].obY := y;
  1681.   IF entry # NIL
  1682.   THEN
  1683.     (* Jetzt hier den String fr den Gruppennamen zusammenbauen *)
  1684.     pCmd := entry;
  1685.     mtUtils.SetObjcString (tr, 0, pCmd^.cmdName);
  1686.     mtUtils.SetState (tr, 0, MagicAES.SELECTED, isSelected (entry, env));
  1687.   ELSE
  1688.     mtUtils.SetObjcStringAdr (tr, 0, CADR(spaceString));
  1689.     mtUtils.SetState (tr, 0, MagicAES.SELECTED, FALSE);
  1690.   END;
  1691.   MagicAES.ObjcDraw (tr, 0, 8, clip);
  1692. END drawCmdEntry;
  1693.  
  1694. PROCEDURE itkButton (tree: ADDRESS; private: ADDRESS; button: INTEGER;
  1695.                      mx, my : INTEGER; kstate: BITSET; clicks: INTEGER): BOOLEAN;
  1696.   VAR str: CatTypes.String255;
  1697.       r  : GrafBase.Rectangle;
  1698.       pCmd: pOneCommand;
  1699.       help : Lists.List;
  1700. BEGIN
  1701.   button := INTEGER(BITSET(button) - {15});
  1702.   mtUtils.ExclState(tree, button, MagicAES.SELECTED);
  1703.   (* Jetzt mal nachsehen, was das fr ein Button ist.
  1704.    * Wenn es OK oder Abbruch ist, dann gehen wir raus
  1705.    *)
  1706.   pCmd := private;
  1707.   IF (button = helpButIdx) 
  1708.   THEN
  1709.     IF BuildHelp  (pCmd, help)
  1710.     THEN
  1711.       CatHelp.DoExternalHelp (help);
  1712.     END;
  1713.     WinDials.WinDialDraw (tree, button, 1, r, FALSE);
  1714.     RETURN FALSE;
  1715.   ELSIF (button = okButIdx) 
  1716.   THEN
  1717.     (* Valid-Check der einzelnen Elemente *)
  1718.     v.bool := GetValues (pCmd, FALSE, FALSE);
  1719.     IF ~v.bool
  1720.     THEN
  1721.       WinDials.WinDialDraw (tree, button, 1, r, FALSE);
  1722.     END;
  1723.     RETURN v.bool;
  1724.   ELSIF (button = previewButIdx)
  1725.   THEN
  1726.     (* Valid-Check der einzelnen Elemente *)
  1727.     v.bool := GetValues (pCmd, FALSE, TRUE);
  1728.     WinDials.WinDialDraw (tree, button, 1, r, FALSE);
  1729.     RETURN FALSE;
  1730.   ELSIF (button = cancelButIdx)
  1731.   THEN 
  1732.     RETURN TRUE
  1733.   ELSE
  1734.     (* User oder Gruppenbutton *)
  1735.     MagicStrings.Assign ("", str);
  1736.     IF mtUtils.InState (tree, button, Bit13)
  1737.     THEN
  1738.       (* Userselect *)
  1739.       IF ListHelp.SelectName (str)
  1740.       THEN
  1741.         mtUtils.SetObjcString (tree, button+1, str);
  1742.       END;
  1743.     ELSIF mtUtils.InState (tree, button, Bit14)
  1744.     THEN
  1745.       (* Gruppenselect *)
  1746.       IF ListHelp.SelectGroup (str, v.card, FALSE, TRUE, FALSE, ListHelp.gsmOther)
  1747.       THEN
  1748.         mtUtils.SetObjcString (tree, button+1, str);
  1749.       END;
  1750.     ELSIF mtUtils.InState (tree, button, Bit15)
  1751.     THEN
  1752.       (* Gruppenselect nur fr Chef *)
  1753.       IF ListHelp.SelectGroup (str, v.card, FALSE, TRUE, FALSE, ListHelp.gsmChief)
  1754.       THEN
  1755.         mtUtils.SetObjcString (tree, button+1, str);
  1756.         WinDials.WinEditChanged (tree, button+1);
  1757.       END;
  1758.     ELSE
  1759.       RETURN FALSE;
  1760.     END;
  1761.     WinDials.WinDialDraw (tree, button, 1, r, FALSE);
  1762.     RETURN FALSE;
  1763.   END;
  1764.   RETURN FALSE;
  1765. END itkButton;
  1766.  
  1767. PROCEDURE itkGetSetValues (tree: ADDRESS; private: ADDRESS; 
  1768.                            set: BOOLEAN; exit: INTEGER);
  1769.   VAR pCmd: pOneCommand;
  1770. BEGIN
  1771.   IF ~set
  1772.   THEN
  1773.     IF exit = okButIdx
  1774.     THEN
  1775.       pCmd := private;
  1776.       v.bool := GetValues (pCmd, TRUE, FALSE);
  1777.     END;
  1778.   END;
  1779. END itkGetSetValues;
  1780.  
  1781. PROCEDURE HandleCommand (pCmd: pOneCommand);
  1782.   VAR exit : INTEGER;
  1783.       r    : GrafBase.Rectangle;
  1784. BEGIN
  1785.   BuildTree (pCmd);
  1786.   IF ~WinDials.OpenWinDial (theTree, TRUE, 
  1787.                             itkGetSetValues,
  1788.                             itkGetSetValues,
  1789.                             itkButton,
  1790.                             WinDials.defDraw,
  1791.                             "",
  1792.                             pCmd)
  1793.   THEN
  1794.     MTE.noWinDialAlert();
  1795.     RemoveTree ();
  1796.     FreeCmdList ();
  1797.     RETURN
  1798.   END;
  1799.   (* Leider ein modaler Dialog, da nicht reentrant *)
  1800.   WinDials.WinDialHandleEvents();
  1801.   RemoveTree ();
  1802.   FreeCmdList ();
  1803. END HandleCommand;
  1804.  
  1805. PROCEDURE setAndGetCmdValues (tree: ADDRESS; private: ADDRESS; set: BOOLEAN; exitBut: INTEGER);
  1806.   VAR pCmd : pOneCommand;
  1807.       pInt : POINTER TO INTEGER;
  1808. BEGIN
  1809.   IF ~set
  1810.   THEN
  1811.     pInt := private;
  1812.     pInt^ := exitBut;
  1813.   END;
  1814. END setAndGetCmdValues;
  1815.  
  1816. PROCEDURE doItkHelp (obj: INTEGER; env, info : ADDRESS; VAR draw : BOOLEAN; VAR exit : BOOLEAN);
  1817. BEGIN
  1818.   CatHelp.DoHelp (CatHelp.itkhelp);
  1819.   mtUtils.SetState (CmdBox, obj, MagicAES.SELECTED, FALSE);
  1820.   WinDials.WinDialDraw (CmdBox, obj, 1, v.r, FALSE);
  1821.   draw := FALSE;
  1822.   exit := FALSE;
  1823. END doItkHelp;
  1824.  
  1825. PROCEDURE SelectCmd (): BOOLEAN;
  1826.   VAR exit : INTEGER;
  1827.       specials : ARRAY [0..1] OF ListDl.specialButHdler;
  1828.       r        : GrafBase.Rectangle;
  1829.       dialHandler: ListDl.ldHandler;
  1830.       pCmd      : pOneCommand;
  1831. BEGIN
  1832.   IF ~InitCmdList()
  1833.   THEN
  1834.     RETURN FALSE;
  1835.   END;
  1836.   
  1837.   Lists.ResetList (cmds);
  1838.   pCmd := Lists.NextEntry (cmds);
  1839.   globalLength := 0;
  1840.   WHILE pCmd # NIL DO
  1841.     globalLength := BinOps.HigherInt (INTEGER(LENGTH(pCmd^.cmdName)), globalLength);
  1842.     pCmd := Lists.NextEntry (cmds);
  1843.   END;
  1844.   INC (globalLength, 2);
  1845.  
  1846.   (* Objektadresse holen *)
  1847.   CmdBox := MausTauschrsc.TreeAddr^[MausTauschrsc.cmdbox];
  1848.   specials[0].objc := MausTauschrsc.chelp;
  1849.   specials[0].proc := doItkHelp;
  1850.  
  1851.   (* Jetzt das Object zusammenbauen *)
  1852.   mtUtils.CalcArea (CmdBox, MausTauschrsc.ccmdbox, r);
  1853.   globalLength := BinOps.HigherInt (globalLength, r.w DIV mtAppl.CharWidth);
  1854.   
  1855.   (* Objectadresse holen *)
  1856.   tr := MausTauschrsc.TreeAddr^[MausTauschrsc.listtxt];
  1857.   Block.Copy (tr, TSIZE(MagicAES.OBJECT), ADR(mTree));
  1858.   Block.Copy (tr^[0].obSpec.TedPtr, TSIZE(MagicAES.TEDINFO), ADR(mTed));
  1859.   mTree[0].obSpec.TedPtr := ADR(mTed);
  1860.   mTree[0].obSpec.TedPtr^.tePtext := ADR (mText);
  1861.   tr := ADR (mTree);
  1862.   tr^[0].obSpec.TedPtr^.teTxtlen := globalLength;
  1863.   tr^[0].obWidth := globalLength * mtAppl.CharWidth;
  1864.   mtUtils.SetState (tr, 0, MagicAES.SELECTED, FALSE);
  1865.   mtUtils.SetState (tr, 0, MagicAES.DISABLED, FALSE);
  1866.  
  1867.   (* WindowDialog vorbereiten *)
  1868.   ListDl.BuildLdHandler (ADR(cmds), 
  1869.                          ListHelp.resetList,
  1870.                          ListHelp.nextEntry,
  1871.                          ListHelp.prevEntry,
  1872.                          countEntries, 
  1873.                          isEnabled, selEntry,
  1874.                          lineToStr, isSelected, 
  1875.                          drawCmdEntry,
  1876.                          0, mtAppl.CharHeight, 
  1877.                          mtAppl.CharWidth, globalLength * mtAppl.CharWidth,
  1878.                          dialHandler);
  1879.  
  1880.   (* ListWinDialog ”ffnen *)
  1881.   IF ListDl.WinListDial (CmdBox, ListDl.ldElemSet{ListDl.ldArrows, ListDl.ldSelect, ListDl.ldDoubleExit, ListDl.ldModal},
  1882.                        dialHandler,
  1883.                        MausTauschrsc.ccmdbox,
  1884.                        MausTauschrsc.ccmdback,
  1885.                        MausTauschrsc.cok,
  1886.                        MausTauschrsc.ccancel,
  1887.                        ADR(exit), MausTauschrsc.cok,
  1888.                        -1,
  1889.                        ListDl.dummyInLoop,
  1890.                        specials,
  1891.                        1,
  1892.                        ListDl.dummyCheckExit,
  1893.                        setAndGetCmdValues,
  1894.                        setAndGetCmdValues,
  1895.                        pCmd)
  1896.   THEN
  1897.     IF (exit = MausTauschrsc.cok) & (pCmd # NIL)
  1898.     THEN
  1899.       HandleCommand (pCmd);
  1900.     END;
  1901.   END;
  1902.   FreeCmdList();
  1903.   RETURN TRUE;
  1904. END SelectCmd;
  1905.  
  1906. (*$Z-*)
  1907. PROCEDURE GetVersion (elem, int: ADDRESS): BOOLEAN;
  1908.   VAR pInt : POINTER TO INTEGER;
  1909.       pCmd : pOneCommand;
  1910. BEGIN
  1911.   pInt := int;
  1912.   pCmd := elem;
  1913.   RETURN (pCmd # NIL) & (pCmd^.cmdIdent = pInt^);
  1914. END GetVersion;
  1915. (*$Z+*)
  1916.  
  1917. PROCEDURE GetCmdVersion (cmd: INTEGER; VAR version: INTEGER): BOOLEAN;
  1918.   VAR found: BOOLEAN;
  1919.       pCmd : pOneCommand;
  1920. BEGIN
  1921.   Lists.ScanEntries (cmds, Lists.forward, GetVersion, ADR(cmd), found);
  1922.   IF found
  1923.   THEN
  1924.     pCmd := Lists.CurrentEntry (cmds);
  1925.     version := pCmd^.cmdVersion;
  1926.   END;
  1927.   RETURN found;
  1928. END GetCmdVersion;
  1929.  
  1930. PROCEDURE CheckSingleCAT(): BOOLEAN;
  1931.   CONST     doubleAlert = '[3][CAT:|CAT oder CatPutz|ist schon gestartet.][[Abbruch]';
  1932.   VAR appName : CatTypes.String127;
  1933.       i       : INTEGER;
  1934.       otherId : INTEGER;
  1935. BEGIN
  1936.   IF CatGlobal.multiTask
  1937.   THEN
  1938.     IF CatGlobal.multiTOS OR (CatGlobal.magIx & (CatGlobal.magIxVer >= $200))
  1939.     THEN
  1940.       (* CAT mittels ApplSearch suchen *)
  1941.       FOR i := 0 TO 12 DO appName[i] := 0C; END;
  1942.       IF MagicAES.ApplSearch (MagicAES.APFIRST, appName, v.int, otherId)
  1943.       THEN
  1944.         REPEAT 
  1945.           Strings.DelTrailingBlanks (appName);
  1946.           IF (otherId # mtAppl.ApplIdent) & 
  1947.               (Strings.StrEqual(appName, 'CAT') OR
  1948.                Strings.StrEqual(appName, 'CATPUTZ'))
  1949.           THEN
  1950.             MTE.info (doubleAlert);
  1951.             (* Tja, leider ein anderes CAT gefunden *)
  1952.             RETURN FALSE
  1953.           END;
  1954.           FOR i := 0 TO 12 DO appName[i] := 0C; END;
  1955.         UNTIL ~MagicAES.ApplSearch (MagicAES.APNEXT, appName, v.int, otherId);
  1956.       END;
  1957.     ELSIF CatGlobal.magIx
  1958.     THEN
  1959.       FOR i := 0 TO MagicAES.AESGlobal.apCount-1 DO
  1960.         IF i # mtAppl.ApplIdent
  1961.         THEN
  1962.           appName[0] := '?';
  1963.           appName[1] := 0C;
  1964.           appName[3] := 0C;
  1965.           appName[2] := CHR(i);
  1966.           IF (MagicAES.ApplFind (ADR(appName)) # 0) 
  1967.           THEN 
  1968.             Strings.DelTrailingBlanks (appName);
  1969.             IF Strings.StrEqual ('CAT', appName) OR
  1970.                Strings.StrEqual ('CATPUTZ', appName)
  1971.             THEN
  1972.               MTE.info (doubleAlert);
  1973.               RETURN FALSE
  1974.             END;
  1975.           END;
  1976.         END;
  1977.       END;
  1978.     END;
  1979.   END;
  1980.   RETURN TRUE;
  1981. END CheckSingleCAT;
  1982.  
  1983. VAR gruppen, adr: ADDRESS;
  1984.  
  1985. BEGIN
  1986.   IF ~CheckSingleCAT () THEN RETURN END;
  1987.   CatGlobal.infPath[0] := 0C; CatGlobal.infName[0] := 0C;
  1988.   IF MausTauschrsc.RscInit()
  1989.   &  MTPaths.ReadInf(CatGlobal.infPath, CatGlobal.infName, FALSE, TRUE)
  1990.   & data.InitDataBase()
  1991.   & GroupSelect.ReadGroupList()
  1992.   THEN
  1993.     gruppen   := MausTauschrsc.TreeAddr^[MausTauschrsc.gruppen];
  1994.     adr       := MausTauschrsc.TreeAddr^[MausTauschrsc.adr];
  1995.     Infofiles.LoadInfoInf(FALSE, FALSE);
  1996.     ListHelp.Init(gruppen, adr);
  1997.     v.bool := SelectCmd();
  1998.   END;
  1999. END ITKCmds.
  2000.